// app/controller/system_controller.js
'use strict';

const { Controller } = require('egg');

class SystemController extends Controller {
  // ==================== 用户管理 ====================
  
  // 获取用户列表
  async getUsers() {
    const { ctx } = this;
    const { page = 1, limit = 20, name, email, role, status } = ctx.query;
    
    try {
      // 参数验证
      const rule = {
        page: { type: 'int', required: false, min: 1 },
        limit: { type: 'int', required: false, min: 1, max: 100 },
        name: { type: 'string', required: false, max: 50 },
        email: { type: 'email', required: false },
        role: { type: 'string', required: false },
        status: { type: 'string', required: false }
      };
      
      ctx.validate(rule);
      
      // 构建查询条件
      const where = {};
      
      if (name) {
        where.name = { [ctx.app.Sequelize.Op.like]: `%${name}%` };
      }
      if (email) {
        where.email = email;
      }
      if (role) {
        where.role = role;
      }
      if (status) {
        where.status = status;
      }

      // 分页查询
      const offset = (parseInt(page) - 1) * parseInt(limit);
      
      // 检查是否有有效的组织ID
      const validOrganizationId = ctx.state.currentOrganizationId && ctx.state.currentOrganizationId !== 1 ? 
        ctx.state.currentOrganizationId : null;
      
      const queryOptions = {
        where,
        order: [['createdAt', 'DESC']],
        limit: parseInt(limit),
        offset
      };
      
      // 根据用户角色和组织ID设置查询条件
      if (ctx.state.user && ctx.state.user.role === 'admin') {
        // 管理员可以看到所有用户，但如果有组织ID限制，则只显示该组织的用户
        if (validOrganizationId) {
          queryOptions.include = [{
            model: ctx.model.OrganizationModel,
            as: 'organizations',
            where: {
              id: validOrganizationId
            },
            through: { attributes: ['role'] }
          }];
        } else {
          // 管理员无组织限制时显示所有用户
          queryOptions.include = [{
            model: ctx.model.OrganizationModel,
            as: 'organizations',
            through: { attributes: ['role'] }
          }];
        }
      } else {
        // 非管理员只能看到同组织的用户
        if (validOrganizationId) {
          queryOptions.include = [{
            model: ctx.model.OrganizationModel,
            as: 'organizations',
            where: {
              id: validOrganizationId
            },
            through: { attributes: ['role'] }
          }];
        } else {
          // 非管理员但没有组织ID，不返回任何用户
          queryOptions.include = [{
            model: ctx.model.OrganizationModel,
            as: 'organizations',
            where: {
              id: -1 // 不匹配任何组织
            },
            through: { attributes: ['role'] }
          }];
        }
      }
      
      const { rows, count } = await ctx.model.UserModel.findAndCountAll(queryOptions);
      
      ctx.page(rows, count, parseInt(page), parseInt(limit));
    } catch (error) {
      ctx.logger.error('获取用户列表失败:', error);
      ctx.error(`获取用户列表失败: ${error.message}`);
    }
  }
  
  // 获取用户详情
  async getUser() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      ctx.logger.info('获取用户详情参数:', { params: ctx.params, id: id, idType: typeof id });
      
      // 参数验证
      const rule = {
        id: { type: 'int', required: true }
      };
      
      // 将id转换为整数后再验证
      const params = { id: parseInt(id) };
      ctx.validate(rule, params);
      
      // 调用服务层方法
      const user = await ctx.service.systemService.getUser(parseInt(id));
      
      if (!user) {
        ctx.error('用户不存在', 404);
        return;
      }
      
      ctx.success(user);
    } catch (error) {
      ctx.logger.error('获取用户详情失败:', error);
      ctx.error(`获取用户详情失败: ${error.message}`);
    }
  }
  
  // 创建用户
  async createUser() {
    const { ctx } = this;
    const userData = ctx.request.body;
    
    try {
      // 使用Joi验证服务进行参数验证
      const validation = ctx.service.validationService.validateCreateUser(userData);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      // 调用服务层方法
      const result = await ctx.service.systemService.createUser(userData);
      
      ctx.success(result, '用户创建成功');
    } catch (error) {
      ctx.logger.error('创建用户失败:', error);
      ctx.error(`创建用户失败: ${error.message}`);
    }
  }
  
  // 更新用户
  async updateUser() {
    const { ctx } = this;
    const { id } = ctx.params;
    const userData = ctx.request.body;
    
    try {
      // 使用Joi验证服务进行参数验证
      // 首先验证ID
      const idValidation = ctx.service.validationService.validateId(parseInt(id));
      if (idValidation.error) {
        ctx.error(`参数验证失败: ${idValidation.error.message}`);
        return;
      }
      
      // 验证用户数据
      const validation = ctx.service.validationService.validateUpdateUser(userData);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      // 调用服务层方法
      const result = await ctx.service.systemService.updateUser(parseInt(id), userData);
      
      ctx.success(result, '用户更新成功');
    } catch (error) {
      ctx.logger.error('更新用户失败:', error);
      ctx.error(`更新用户失败: ${error.message}`);
    }
  }
  
  // 删除用户
  async deleteUser() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      // 参数验证
      const rule = {
        id: { type: 'int', required: true }
      };
      
      // 将id转换为整数后再验证
      const params = { id: parseInt(id) };
      ctx.validate(rule, params);
      
      // 调用服务层方法
      await ctx.service.systemService.deleteUser(parseInt(id));
      
      ctx.success(null, '用户删除成功');
    } catch (error) {
      ctx.logger.error('删除用户失败:', error);
      ctx.error(`删除用户失败: ${error.message}`);
    }
  }
  
  // 批量删除用户
  async batchDeleteUsers() {
    const { ctx } = this;
    const { ids } = ctx.request.body;
    
    try {
      // 参数验证
      const rule = {
        ids: { type: 'array', required: true, itemType: 'int' }
      };
      
      ctx.validate(rule, { ids });
      
      // 调用服务层方法
      await ctx.service.systemService.batchDeleteUsers(ids);
      
      ctx.success(null, '用户批量删除成功');
    } catch (error) {
      ctx.logger.error('批量删除用户失败:', error);
      ctx.error(`批量删除用户失败: ${error.message}`);
    }
  }
  
  // 批量更新用户状态
  async batchUpdateUserStatus() {
    const { ctx } = this;
    const { ids, status } = ctx.request.body;
    
    try {
      // 参数验证
      const rule = {
        ids: { type: 'array', required: true, itemType: 'int' },
        status: { type: 'string', required: true }
      };
      
      ctx.validate(rule, { ids, status });
      
      // 调用服务层方法
      await ctx.service.systemService.batchUpdateUserStatus(ids, status);
      
      ctx.success(null, '用户状态批量更新成功');
    } catch (error) {
      ctx.logger.error('批量更新用户状态失败:', error);
      ctx.error(`批量更新用户状态失败: ${error.message}`);
    }
  }
  
  // ==================== 角色权限 ====================
  
  // 获取角色列表
  async getRoles() {
    const { ctx } = this;
    const { page = 1, limit = 20, name } = ctx.query;
    
    try {
      // 参数验证
      const rule = {
        page: { type: 'int', required: false, min: 1 },
        limit: { type: 'int', required: false, min: 1, max: 100 },
        name: { type: 'string', required: false, max: 50 }
      };
      
      ctx.validate(rule);
      
      // 调用服务层方法
      const result = await ctx.service.systemService.getRoles({
        page: parseInt(page),
        limit: parseInt(limit),
        name
      });
      
      ctx.page(result.list, result.pagination.total, result.pagination.page, result.pagination.limit);
    } catch (error) {
      ctx.logger.error('获取角色列表失败:', error);
      ctx.error(`获取角色列表失败: ${error.message}`);
    }
  }
  
  // 获取角色详情
  async getRole() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      // 参数验证
      const rule = {
        id: { type: 'int', required: true }
      };
      
      // 将id转换为整数后再验证
      const params = { id: parseInt(id) };
      ctx.validate(rule, params);
      
      // 调用服务层方法
      const role = await ctx.service.systemService.getRole(parseInt(id));
      
      if (!role) {
        ctx.error('角色不存在', 404);
        return;
      }
      
      ctx.success(role);
    } catch (error) {
      ctx.logger.error('获取角色详情失败:', error);
      ctx.error(`获取角色详情失败: ${error.message}`);
    }
  }
  
  // 创建角色
  async createRole() {
    const { ctx } = this;
    const roleData = ctx.request.body;
    
    try {
      // 使用Joi验证服务进行参数验证
      const validation = ctx.service.validationService.validateCreateRole(roleData);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      // 调用服务层方法
      const result = await ctx.service.systemService.createRole(roleData);
      
      ctx.success(result, '角色创建成功');
    } catch (error) {
      ctx.logger.error('创建角色失败:', error);
      ctx.error(`创建角色失败: ${error.message}`);
    }
  }
  
  // 更新角色
  async updateRole() {
    const { ctx } = this;
    const { id } = ctx.params;
    const roleData = ctx.request.body;
    
    try {
      // 使用Joi验证服务进行参数验证
      // 首先验证ID
      const idValidation = ctx.service.validationService.validateId(parseInt(id));
      if (idValidation.error) {
        ctx.error(`参数验证失败: ${idValidation.error.message}`);
        return;
      }
      
      // 验证角色数据
      const validation = ctx.service.validationService.validateUpdateRole(roleData);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      // 调用服务层方法
      const result = await ctx.service.systemService.updateRole(parseInt(id), roleData);
      
      ctx.success(result, '角色更新成功');
    } catch (error) {
      ctx.logger.error('更新角色失败:', error);
      ctx.error(`更新角色失败: ${error.message}`);
    }
  }
  
  // 删除角色
  async deleteRole() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      // 参数验证
      const rule = {
        id: { type: 'int', required: true }
      };
      
      const idInt = parseInt(id);
      ctx.validate(rule, { id: idInt });
      
      // 调用服务层方法
      await ctx.service.systemService.deleteRole(idInt);
      
      ctx.success(null, '角色删除成功');
    } catch (error) {
      ctx.logger.error('删除角色失败:', error);
      ctx.error(`删除角色失败: ${error.message}`);
    }
  }
  
  // ==================== 操作日志 ====================
  
  // 获取操作日志列表
  async getOperationLogs() {
    const { ctx } = this;
    const { 
      page = 1, 
      limit = 20, 
      userId, 
      action, 
      module,
      startDate,
      endDate
    } = ctx.query;
    
    try {
      // 参数验证
      const rule = {
        page: { type: 'int', required: false, min: 1 },
        limit: { type: 'int', required: false, min: 1, max: 100 },
        userId: { type: 'int', required: false },
        action: { type: 'string', required: false },
        module: { type: 'string', required: false },
        startDate: { type: 'string', required: false },
        endDate: { type: 'string', required: false }
      };
      
      ctx.validate(rule);
      
      // 调用服务层方法
      const result = await ctx.service.systemService.getOperationLogs({
        page: parseInt(page),
        limit: parseInt(limit),
        userId: userId ? parseInt(userId) : undefined,
        action,
        module,
        startDate,
        endDate
      });
      
      ctx.page(result.list, result.pagination.total, result.pagination.page, result.pagination.limit);
    } catch (error) {
      ctx.logger.error('获取操作日志列表失败:', error);
      ctx.error(`获取操作日志列表失败: ${error.message}`);
    }
  }
  
  // 获取操作日志详情
  async getOperationLog() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      // 参数验证
      const rule = {
        id: { type: 'int', required: true }
      };
      
      ctx.validate(rule, { id });
      
      // 调用服务层方法
      const log = await ctx.service.systemService.getOperationLog(parseInt(id));
      
      if (!log) {
        ctx.error('操作日志不存在', 404);
        return;
      }
      
      ctx.success(log);
    } catch (error) {
      ctx.logger.error('获取操作日志详情失败:', error);
      ctx.error(`获取操作日志详情失败: ${error.message}`);
    }
  }
  
  // 删除操作日志
  async deleteOperationLog() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      // 参数验证
      const rule = {
        id: { type: 'int', required: true }
      };
      
      ctx.validate(rule, { id });
      
      // 调用服务层方法
      await ctx.service.systemService.deleteOperationLog(parseInt(id));
      
      ctx.success(null, '操作日志删除成功');
    } catch (error) {
      ctx.logger.error('删除操作日志失败:', error);
      ctx.error(`删除操作日志失败: ${error.message}`);
    }
  }
  
  // ==================== 系统设置 ====================
  
  // 获取系统设置
  async getSystemSettings() {
    const { ctx } = this;
    
    try {
      // 调用服务层方法
      const settings = await ctx.service.systemService.getSystemSettings();
      
      ctx.success(settings);
    } catch (error) {
      ctx.logger.error('获取系统设置失败:', error);
      ctx.error(`获取系统设置失败: ${error.message}`);
    }
  }
  
  // 更新系统设置
  async updateSystemSettings() {
    const { ctx } = this;
    const settings = ctx.request.body;
    
    try {
      // 调用服务层方法
      await ctx.service.systemService.updateSystemSettings(settings);
      
      ctx.success(null, '系统设置更新成功');
    } catch (error) {
      ctx.logger.error('更新系统设置失败:', error);
      ctx.error(`更新系统设置失败: ${error.message}`);
    }
  }
  
  // ==================== 快捷键设置 ====================
  
  // 获取用户快捷键设置
  async getUserShortcuts() {
    const { ctx } = this;
    
    try {
      let userId = 1; // 默认用户ID
      
      // 检查用户是否已认证
      if (ctx.state && ctx.state.user && ctx.state.user.id) {
        userId = ctx.state.user.id; // 从认证信息中获取用户ID
      }
      
      // 调用服务层方法
      const shortcuts = await ctx.service.systemService.getUserShortcuts(userId);
      
      ctx.success(shortcuts);
    } catch (error) {
      ctx.logger.error('获取用户快捷键设置失败:', error);
      ctx.error(`获取用户快捷键设置失败: ${error.message}`);
    }
  }
  
  // 更新用户快捷键设置
  async updateUserShortcuts() {
    const { ctx } = this;
    const shortcuts = ctx.request.body;
    
    try {
      // 检查用户是否已认证
      if (!ctx.state || !ctx.state.user || !ctx.state.user.id) {
        ctx.error('用户未认证', 401);
        return;
      }
      
      const userId = ctx.state.user.id; // 从认证信息中获取用户ID
      
      // 调用服务层方法
      await ctx.service.systemService.updateUserShortcuts(userId, shortcuts);
      
      ctx.success(null, '快捷键设置更新成功');
    } catch (error) {
      ctx.logger.error('更新用户快捷键设置失败:', error);
      ctx.error(`更新用户快捷键设置失败: ${error.message}`);
    }
  }
  
  // ==================== UI配置 ====================
  
  // 获取UI配置
  async getUIConfig() {
    const { ctx } = this;
    const { pageKey } = ctx.query;
    
    try {
      // 检查用户是否已认证
      if (!ctx.state || !ctx.state.user || !ctx.state.user.id) {
        ctx.error('用户未认证', 401);
        return;
      }
      
      const userId = ctx.state.user.id; // 从认证信息中获取用户ID
      
      // 参数验证
      const rule = {
        pageKey: { type: 'string', required: true }
      };
      
      ctx.validate(rule, ctx.query);
      
      // 调用服务层方法
      const config = await ctx.service.systemService.getUIConfig(userId, pageKey);
      
      ctx.success(config);
    } catch (error) {
      ctx.logger.error('获取UI配置失败:', error);
      ctx.error(`获取UI配置失败: ${error.message}`);
    }
  }
  
  // 保存UI配置
  async saveUIConfig() {
    const { ctx } = this;
    const { pageKey, config } = ctx.request.body;
    
    try {
      // 检查用户是否已认证
      if (!ctx.state || !ctx.state.user || !ctx.state.user.id) {
        ctx.error('用户未认证', 401);
        return;
      }
      
      const userId = ctx.state.user.id; // 从认证信息中获取用户ID
      
      // 参数验证
      const rule = {
        pageKey: { type: 'string', required: true },
        config: { type: 'object', required: true }
      };
      
      ctx.validate(rule);
      
      // 调用服务层方法
      await ctx.service.systemService.saveUIConfig(userId, pageKey, config);
      
      ctx.success(null, 'UI配置保存成功');
    } catch (error) {
      ctx.logger.error('保存UI配置失败:', error);
      ctx.error(`保存UI配置失败: ${error.message}`);
    }
  }
  
  // 删除UI配置
  async deleteUIConfig() {
    const { ctx } = this;
    const { pageKey } = ctx.request.body;
    
    try {
      // 检查用户是否已认证
      if (!ctx.state || !ctx.state.user || !ctx.state.user.id) {
        ctx.error('用户未认证', 401);
        return;
      }
      
      const userId = ctx.state.user.id; // 从认证信息中获取用户ID
      
      // 参数验证
      const rule = {
        pageKey: { type: 'string', required: true }
      };
      
      ctx.validate(rule);
      
      // 调用服务层方法
      await ctx.service.systemService.deleteUIConfig(userId, pageKey);
      
      ctx.success(null, 'UI配置删除成功');
    } catch (error) {
      ctx.logger.error('删除UI配置失败:', error);
      ctx.error(`删除UI配置失败: ${error.message}`);
    }
  }
  
  // ==================== 用户分组 ====================
  
  // 获取所有用户分组
  async getUserGroups() {
    const { ctx } = this;
    
    try {
      // 调用服务层方法
      const groups = await ctx.service.systemService.getUserGroups();
      
      ctx.success(groups);
    } catch (error) {
      ctx.logger.error('获取用户分组失败:', error);
      ctx.error(`获取用户分组失败: ${error.message}`);
    }
  }
  
  // 创建用户分组
  async createUserGroup() {
    const { ctx } = this;
    const groupData = ctx.request.body;
    
    try {
      // 使用Joi验证服务进行参数验证
      const validation = ctx.service.validationService.validateCreateUserGroup(groupData);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      // 调用服务层方法
      const result = await ctx.service.systemService.createUserGroup(groupData);
      
      ctx.success(result, '用户分组创建成功');
    } catch (error) {
      ctx.logger.error('创建用户分组失败:', error);
      ctx.error(`创建用户分组失败: ${error.message}`);
    }
  }
  
  // 更新用户分组
  async updateUserGroup() {
    const { ctx } = this;
    const { id } = ctx.params;
    const groupData = ctx.request.body;
    
    try {
      // 使用Joi验证服务进行参数验证
      // 首先验证ID
      const idValidation = ctx.service.validationService.validateId(parseInt(id));
      if (idValidation.error) {
        ctx.error(`参数验证失败: ${idValidation.error.message}`);
        return;
      }
      
      // 验证分组数据
      const validation = ctx.service.validationService.validateUpdateUserGroup(groupData);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      // 调用服务层方法
      const result = await ctx.service.systemService.updateUserGroup(parseInt(id), groupData);
      
      ctx.success(result, '用户分组更新成功');
    } catch (error) {
      ctx.logger.error('更新用户分组失败:', error);
      ctx.error(`更新用户分组失败: ${error.message}`);
    }
  }
  
  // 删除用户分组
  async deleteUserGroup() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      // 参数验证
      const rule = {
        id: { type: 'int', required: true }
      };
      
      ctx.validate(rule, { id });
      
      // 调用服务层方法
      await ctx.service.systemService.deleteUserGroup(parseInt(id));
      
      ctx.success(null, '用户分组删除成功');
    } catch (error) {
      ctx.logger.error('删除用户分组失败:', error);
      ctx.error(`删除用户分组失败: ${error.message}`);
    }
  }
  
  // 获取分组成员
  async getGroupMembers() {
    const { ctx } = this;
    const { groupId } = ctx.query;
    
    try {
      // 参数验证
      const rule = {
        groupId: { type: 'int', required: true }
      };
      
      ctx.validate(rule, { groupId });
      
      // 调用服务层方法
      const members = await ctx.service.systemService.getGroupMembers(parseInt(groupId));
      
      ctx.success(members);
    } catch (error) {
      ctx.logger.error('获取分组成员失败:', error);
      ctx.error(`获取分组成员失败: ${error.message}`);
    }
  }
  
  // 添加用户到分组
  async addUserToGroup() {
    const { ctx } = this;
    const { userId, groupId } = ctx.request.body;
    
    try {
      // 参数验证
      const rule = {
        userId: { type: 'int', required: true },
        groupId: { type: 'int', required: true }
      };
      
      ctx.validate(rule, { userId, groupId });
      
      // 调用服务层方法
      const result = await ctx.service.systemService.addUserToGroup(userId, groupId);
      
      ctx.success(result, '用户添加到分组成功');
    } catch (error) {
      ctx.logger.error('添加用户到分组失败:', error);
      ctx.error(`添加用户到分组失败: ${error.message}`);
    }
  }
  
  // 从分组中移除用户
  async removeUserFromGroup() {
    const { ctx } = this;
    const { userId, groupId } = ctx.request.body;
    
    try {
      // 参数验证
      const rule = {
        userId: { type: 'int', required: true },
        groupId: { type: 'int', required: true }
      };
      
      ctx.validate(rule, { userId, groupId });
      
      // 调用服务层方法
      await ctx.service.systemService.removeUserFromGroup(userId, groupId);
      
      ctx.success(null, '用户从分组中移除成功');
    } catch (error) {
      ctx.logger.error('从分组中移除用户失败:', error);
      ctx.error(`从分组中移除用户失败: ${error.message}`);
    }
  }
}

module.exports = SystemController;